¿Qué es el operador "->" en C ++?

-> no es un operador. De hecho, son dos operadores separados, - y>.
El código del condicional disminuye x, mientras devuelve el valor original (no decrementado) de x, y luego compara el valor original con 0 usando el operador>.
Para comprender mejor, la declaración podría escribirse de la siguiente manera:
mientras ((x--)> 0)
|
O para algo completamente diferente ... x se desliza a 0.
mientras que (x - \
\
\
\
> 0)
printf ("% d", x);
No tan matemático, pero ... cada imagen pinta mil palabras ...
|
Ese es un operador muy complicado, por lo que incluso ISO / IEC JTC1 (Comité Técnico Conjunto 1) colocó su descripción en dos partes diferentes del Estándar C ++.
Bromas aparte, son dos operadores diferentes: - y> descritos respectivamente en §5.2.6 / 2 y §5.9 del Estándar C ++ 03.
|
Es equivalente a
mientras (x--> 0)
x-- (decremento posterior) es equivalente ax = x-1, por lo que el código se transforma en:
while (x> 0) {
x = x-1;
// lógica
}
X--; // El decremento posterior realizado cuando x <= 0
|
x puede ir a cero incluso más rápido en la dirección opuesta:
int x = 10;
mientras (0 <---- x)
{
printf ("% d", x);
}
8 6 4 2
¡Puedes controlar la velocidad con una flecha!
int x = 100;
mientras (0 <-------------------- x)
{
printf ("% d", x);
}
90 80 70 60 50 40 30 20 10
;)
|
Sus
#include 
int main (void) {
int x = 10;
while (x--> 0) {// x va a 0
printf ("% d", x);
}
return 0;
}
Solo el espacio hace que las cosas se vean divertidas, - disminuye y> compara.
|
El uso de -> tiene relevancia histórica. Reducir fue (y sigue siendo en algunos casos) más rápido que incrementar en la arquitectura x86. El uso de -> sugiere que x va a 0 y atrae a aquellos con antecedentes matemáticos.
|
mientras (x--> 0)
así es como se analiza.
|
Totalmente geek, pero usaré esto:
#define as; while
int main (int argc, char * argv [])
{
int n = atoi (argv [1]);
hacer printf ("n es% d \ n", n) as (n -> 0);
return 0;
}
|
Un libro que leí (no recuerdo correctamente qué libro) decía: Los compiladores intentan analizar las expresiones hasta el token más grande utilizando la regla de izquierda a derecha.
En este caso, la expresión:
x -> 0
Analiza a tokens más grandes:
ficha 1: x
ficha 2: -
ficha 3:>
ficha 4: 0
concluir: x--> 0
La misma regla se aplica a esta expresión:
a ----- b
Después de analizar:
ficha 1: a
ficha 2: -
ficha 3: -
ficha 4: -
ficha 5: b
concluir: (a -) - - b
Espero que esto ayude a entender la complicada expresión ^^
|
Esto es exactamente lo mismo que
mientras (x--)
{
printf ("% d", x);
}
para números no negativos
|
De todos modos, ahora tenemos un operador "va a". "->" es fácil de recordar como una dirección, y "mientras x va a cero" tiene sentido directo.
Además, es un poco más eficiente que "para (x = 10; x> 0; x -)" en algunas plataformas.
|
Este código primero compara x y 0 y luego disminuye x. (También se dice en la primera respuesta: está disminuyendo posteriormente x y luego comparando x y 0 con el operador>). Vea el resultado de este código:
9 8 7 6 5 4 3 2 1 0
Ahora primero comparamos y luego disminuimos al ver 0 en la salida.
Si primero queremos disminuir y luego comparar, use este código:
#include 
int main (vacío)
{
int x = 10;
while (--x> 0) // x va a 0
{
printf ("% d", x);
}
return 0;
}
Esa salida es:
9 8 7 6 5 4 3 2 1
|
Mi compilador imprimirá 9876543210 cuando ejecuto este código.
#include 
int main ()
{
int x = 10;
while (x -> 0) // x va a 0
{
std :: cout << x;
}
}
Como se esperaba. El while (x--> 0) en realidad significa while (x> 0). La publicación x-- disminuye x.
mientras (x> 0)
{
X--;
std :: cout << x;
}
es una forma diferente de escribir lo mismo.
Sin embargo, es bueno que el original se vea como "mientras x va a 0".
|
Falta un espacio entre - y>. x es post decrementado, es decir, decrementado después de verificar la condición x> 0?.
|
- es el operador de decremento y> es el operador mayor que.
Los dos operadores se aplican como uno solo como ->.
|
Es una combinación de dos operadores. Primero: es para disminuir el valor y> es para verificar si el valor es mayor que el operando de la derecha.
#include 
int main ()
{
int x = 10;
mientras (x--> 0)
printf ("% d", x);
return 0;
}
La salida será:
9 8 7 6 5 4 3 2 1 0
|
En realidad, x es post-decreciente y con esa condición se está comprobando. No es ->, es (x--)> 0
Nota: el valor de x se cambia después de que se verifica la condición, ya que se post-decrementa. También pueden ocurrir algunos casos similares, por ejemplo:
-> x -> 0
++> x ++> 0
-> = x -> = 0
++> = x ++> = 0
|
C y C ++ obedecen la regla de "masticación máxima". De la misma manera que a --- b se traduce a (a--) - b, en su caso x -> 0 se traduce en (x -)> 0.
Lo que la regla dice esencialmente es que yendo de izquierda a derecha, las expresiones se forman tomando el máximo de caracteres que formarán una expresión válida.
|
¿Por qué tanta complicación?
La respuesta simple a la pregunta original es simplemente:
#include 
int main ()
{
int x = 10;
mientras (x>0)
{
printf ("% d", x);
x = x-1;
}
}
Hace la misma cosa. No estoy diciendo que debas hacerlo así, pero hace lo mismo y habría respondido la pregunta en una publicación.
La x-- es una abreviatura de lo anterior, y> es solo un operador normal mayor que. ¡No hay gran misterio!
Hay demasiada gente que complica las cosas simples hoy en día;)
|
De la manera convencional, definiríamos una condición en el paréntesis del ciclo while () y una condición de terminación dentro de las llaves {}, pero -> define ambas a la vez.
Por ejemplo:
int abc (vacío)
{
int a = 5
while ((a--)> 0) // Decremento y comparación ambos a la vez
{
// Código
}
}
Esto reduce ay ejecuta el ciclo mientras a es mayor que 0.
Convencionalmente, sería como:
int abc (vacío)
{
int a = 5;
mientras (a> 0)
{
una--;
// Código
}
una--;
}
En ambos sentidos, hacemos lo mismo y logramos los mismos objetivos.
|
(x -> 0) significa (x--> 0).
Puede usar (x ->) Salida: 9 8 7 6 5 4 3 2 1 0
Puede usar (- x> 0) Es medio (--x> 0) Salida: 9 8 7 6 5 4 3 2 1
Puedes usar
(- \
\
x> 0)
Salida: 9 8 7 6 5 4 3 2 1
Puedes usar
(\
\
x -> 0)
Salida: 9 8 7 6 5 4 3 2 1 0
Puedes usar
(\
\
x -> 0
\
\
)
Salida: 9 8 7 6 5 4 3 2 1 0
También puedes usar
(
X
->
)
Salida: 9 8 7 6 5 4 3 2 1 0
Del mismo modo, puede probar muchos métodos para ejecutar este comando con éxito.
|
Aquí - es el operador de decremento posterior unario.
while (x--> 0) // x va a 0
{
printf ("% d", x);
}
Al principio, la condición se evaluará como
(x> 0) // 10> 0
Ahora que la condición es verdadera, entrará en el ciclo con un valor decrementado
x-- // x = 9
Por eso el primer valor impreso es 9
Y así. En el último ciclo x = 1, entonces la condición es verdadera. Según el operador unario, el valor cambió ax = 0 en el momento de la impresión.
Ahora, x = 0, que evalúa la condición (x> 0) como falsa y el ciclo while sale.
|
Esto -> no es un operador en absoluto. Tenemos un operador como ->, pero no como ->. Es solo una interpretación incorrecta de while (x--> 0) que simplemente significa que x tiene el operador de decremento posterior y este ciclo se ejecutará hasta que sea mayor que cero.
Otra forma sencilla de escribir este código sería while (x--). El ciclo while se detendrá siempre que obtenga una condición falsa y aquí solo hay un caso, es decir, 0. Por lo tanto, se detendrá cuando el valor x se reduzca a cero.
|
Pregunta muy activa. Gana 10 de reputación para responder a esta pregunta. El requisito de reputación ayuda a proteger esta pregunta del spam y de la actividad sin respuesta.
No es la respuesta que estás buscando? Explore otras preguntas etiquetadas operadores de c ++ c code-formatting standards-compliance o haga su propia pregunta.